---
title: "核心語法與結構對比"
description: "從 JavaScript 視角學習 Rust 基礎語法，包括變數宣告、資料型別、控制流和函式定義"
---

# 核心語法與結構對比

## 📖 學習目標

透過對比 JavaScript 和 Rust 的基礎語法，快速掌握 Rust 的核心概念。我們將從你熟悉的 JavaScript 語法出發，逐步引入 Rust 的語法特性。

---

## 🎯 變數宣告與作用域

### JavaScript 的變數宣告

在 JavaScript 中，我們使用 `var`、`let` 和 `const` 來宣告變數：

<UniversalEditor title="JavaScript 變數宣告" compare={true}>
```javascript !! js
// JavaScript 變數宣告
var oldWay = "不推薦使用";
let mutableVar = "可以重新賦值";
const immutableVar = "不能重新賦值";

// 變數可以重新賦值
mutableVar = "新的值";
console.log(mutableVar); // 輸出: 新的值

// const 宣告的變數不能重新賦值
// immutableVar = "嘗試修改"; // 這會報錯
```
</UniversalEditor>

### Rust 的變數宣告

Rust 使用 `let` 關鍵字宣告變數，預設是不可變的：

<UniversalEditor title="Rust 變數宣告" compare={true}>
```rust !! rs
// Rust 變數宣告
let immutable_var = "預設不可變";
let mut mutable_var = "可以重新賦值"; // 需要 mut 關鍵字

// 可變變數可以重新賦值
mutable_var = "新的值";
println!("{}", mutable_var); // 輸出: 新的值

// 不可變變數不能重新賦值
// immutable_var = "嘗試修改"; // 編譯錯誤！

// 變數遮蔽（shadowing）- Rust 特有概念
let x = 5;
let x = x + 1; // 建立新的變數 x，遮蔽原來的 x
println!("x = {}", x); // 輸出: x = 6
```
</UniversalEditor>

### 關鍵差異

1.  **預設不可變性**: Rust 中變數預設不可變，需要 `mut` 關鍵字才能修改
2.  **變數遮蔽**: Rust 允許在同一作用域內重新宣告同名變數
3.  **型別推導**: Rust 編譯器可以自動推導變數型別

---

## 📊 基本資料型別對比

### JavaScript 的資料型別

JavaScript 是動態型別語言：

<UniversalEditor title="JavaScript 資料型別" compare={true}>
```javascript !! js
// JavaScript 基本資料型別
let number = 42;           // Number
let string = "Hello";      // String
let boolean = true;        // Boolean
let array = [1, 2, 3];     // Array
let object = {name: "Rust"}; // Object
let nullValue = null;      // null
let undefinedValue;        // undefined

// 型別檢查
console.log(typeof number);        // "number"
console.log(typeof string);        // "string"
console.log(typeof boolean);       // "boolean"
console.log(Array.isArray(array)); // true
```
</UniversalEditor>

### Rust 的資料型別

Rust 是靜態型別語言，型別在編譯時確定：

<UniversalEditor title="Rust 資料型別" compare={true}>
```rust !! rs
// Rust 基本資料型別
let integer: i32 = 42;           // 32位有符號整數
let unsigned: u32 = 42;          // 32位無符號整數
let float: f64 = 3.14;           // 64位浮點數
let boolean: bool = true;        // 布林值
let character: char = 'A';       // Unicode 字元
let string: String = String::from("Hello"); // 字串
let string_slice: &str = "World"; // 字串切片

// 陣列 - 固定長度
let array: [i32; 5] = [1, 2, 3, 4, 5];

// 元組 - 可以包含不同型別
let tuple: (i32, f64, &str) = (500, 6.4, "hello");

// 存取陣列和元組元素
println!("陣列第一個元素: {}", array[0]);
println!("元組第一個元素: {}", tuple.0);
```
</UniversalEditor>

### 型別系統差異

1.  **靜態 vs 動態**: Rust 在編譯時檢查型別，JavaScript 在執行時檢查
2.  **整數型別**: Rust 有多種整數型別（i8, i16, i32, i64, u8, u16, u32, u64）
3.  **字串**: Rust 區分 `String`（擁有所有權）和 `&str`（借用）

---

## 🔄 控制流對比

### JavaScript 的控制流

<UniversalEditor title="JavaScript 控制流" compare={true}>
```javascript !! js
// JavaScript 條件語句
let age = 18;

if (age >= 18) {
    console.log("成年人");
} else if (age >= 12) {
    console.log("青少年");
} else {
    console.log("兒童");
}

// switch 語句
let day = "Monday";
switch (day) {
    case "Monday":
        console.log("星期一");
        break;
    case "Tuesday":
        console.log("星期二");
        break;
    default:
        console.log("其他日子");
}

// 迴圈
for (let i = 0; i < 5; i++) {
    console.log(i);
}

let numbers = [1, 2, 3, 4, 5];
for (let num of numbers) {
    console.log(num);
}
```
</UniversalEditor>

### Rust 的控制流

<UniversalEditor title="Rust 控制流" compare={true}>
```rust !! rs
// Rust 條件語句
let age = 18;

if age >= 18 {
    println!("成年人");
} else if age >= 12 {
    println!("青少年");
} else {
    println!("兒童");
}

// if 是表達式，可以賦值
let status = if age >= 18 { "成年人" } else { "未成年人" };
println!("狀態: {}", status);

// match 語句（類似 switch，但更強大）
let day = "Monday";
match day {
    "Monday" => println!("星期一"),
    "Tuesday" => println!("星期二"),
    _ => println!("其他日子"), // _ 是通配符
}

// 迴圈
for i in 0..5 {
    println!("{}", i);
}

let numbers = vec![1, 2, 3, 4, 5];
for num in &numbers {
    println!("{}", num);
}

// while 迴圈
let mut count = 0;
while count < 5 {
    println!("count: {}", count);
    count += 1;
}

// loop 迴圈（無限迴圈）
let mut counter = 0;
loop {
    counter += 1;
    if counter > 5 {
        break; // 跳出迴圈
    }
    println!("counter: {}", counter);
}
```
</UniversalEditor>

### 控制流差異

1.  **if 表達式**: Rust 的 `if` 可以傳回值，用於賦值
2.  **match 語句**: 比 JavaScript 的 `switch` 更強大，支援模式匹配
3.  **迴圈語法**: Rust 使用 `for in` 語法，更簡潔

---

## 🏗️ 函式定義對比

### JavaScript 的函式

<UniversalEditor title="JavaScript 函式定義" compare={true}>
```javascript !! js
// JavaScript 函式定義
function greet(name) {
    return `Hello, ${name}!`;
}

// 箭頭函式
const greetArrow = (name) => {
    return `Hello, ${name}!`;
};

// 簡化的箭頭函式
const greetSimple = (name) => `Hello, ${name}!`;

console.log(greet("World"));
console.log(greetArrow("World"));
console.log(greetSimple("World"));
```
</UniversalEditor>

### Rust 的函式

<UniversalEditor title="Rust 函式定義" compare={true}>
```rust !! rs
// Rust 函式定義
// 參數型別和傳回值型別必須指定
fn greet(name: &str) -> String {
    // 最後一個表達式不需要 'return' 關鍵字
    format!("Hello, {}!", name)
}

// 另一個函式
fn add(a: i32, b: i32) -> i32 {
    a + b // 這是一個表達式，所以它會傳回值
}

fn main() {
    println!("{}", greet("World"));
    println!("1 + 2 = {}", add(1, 2));
}
```
</UniversalEditor>

### 函式差異

1.  **型別註解**: Rust 要求函式參數和傳回值有明確的型別註解。
2.  **傳回值**: 在 Rust 中，函式中的最後一個表達式會自動傳回（不需要 `return` 關鍵字，省略分號）。
3.  **箭頭函式**: Rust 沒有與 JavaScript 的箭頭函式等價的語法，但閉包（closures）有類似的功能。

---

## 📚 總結

在本模組中，我們比較了 JavaScript 和 Rust 的核心語法。你現在應該對以下內容有了基本的了解：
- 如何在 Rust 中宣告變數及其不可變性。
- 基本資料型別的差異。
- Rust 中強大的控制流結構，如 `match` 和 `if` 表達式。
- 使用明確型別定義函式的語法。

接下來，我們將探討兩種語言的模組系統。 